```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Spring Bean 生命周期详解</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        :root {
            --primary: #4f46e5;
            --secondary: #10b981;
            --accent: #f59e0b;
            --dark: #1e293b;
            --light: #f8fafc;
        }
        
        body {
            font-family: 'Noto Sans SC', 'Noto Serif SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: var(--dark);
            line-height: 1.8;
            background-color: #f9fafb;
        }
        
        .hero {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        
        .card {
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
        }
        
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 15px rgba(0, 0, 0, 0.1);
        }
        
        .section-title {
            position: relative;
            padding-bottom: 0.5rem;
        }
        
        .section-title:after {
            content: '';
            position: absolute;
            left: 0;
            bottom: 0;
            width: 50px;
            height: 3px;
            background: var(--primary);
        }
        
        .mermaid-container {
            background: white;
            border-radius: 0.5rem;
            padding: 1.5rem;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
        }
        
        .code-block {
            background: #282c34;
            color: #abb2bf;
            border-radius: 0.5rem;
            padding: 1.5rem;
            font-family: 'Courier New', Courier, monospace;
            position: relative;
        }
        
        .code-block:before {
            content: 'Java';
            position: absolute;
            top: 0;
            right: 0;
            padding: 0.25rem 0.75rem;
            background: rgba(255,255,255,0.1);
            border-bottom-left-radius: 0.5rem;
            font-size: 0.8rem;
        }
        
        .dropcap:first-letter {
            float: left;
            font-size: 3.5rem;
            line-height: 1;
            margin-right: 0.5rem;
            color: var(--primary);
            font-weight: bold;
        }
    </style>
</head>
<body>
    <!-- Hero Section -->
    <section class="hero text-white py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-2/3 mb-10 md:mb-0">
                    <h1 class="text-4xl md:text-5xl font-bold mb-4 leading-tight">Spring Bean 生命周期</h1>
                    <p class="text-xl opacity-90 mb-8">深入理解Spring框架中Bean的创建、初始化和销毁全过程</p>
                    <div class="flex items-center space-x-4">
                        <span class="bg-white bg-opacity-20 px-4 py-2 rounded-full flex items-center">
                            <i class="fas fa-code-branch mr-2"></i>Spring Framework
                        </span>
                        <span class="bg-white bg-opacity-20 px-4 py-2 rounded-full flex items-center">
                            <i class="fas fa-layer-group mr-2"></i>IoC容器
                        </span>
                    </div>
                </div>
                <div class="md:w-1/3">
                    <div class="bg-white bg-opacity-20 p-6 rounded-xl backdrop-blur-sm">
                        <h3 class="text-xl font-semibold mb-4">核心要点</h3>
                        <ul class="space-y-2">
                            <li class="flex items-start">
                                <i class="fas fa-check-circle mt-1 mr-2 text-green-200"></i>
                                <span>实例化、属性设置和初始化</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check-circle mt-1 mr-2 text-green-200"></i>
                                <span>生命周期回调方法</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check-circle mt-1 mr-2 text-green-200"></i>
                                <span>作用域管理</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check-circle mt-1 mr-2 text-green-200"></i>
                                <span>BeanPostProcessor扩展</span>
                            </li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="container mx-auto max-w-5xl px-4 md:px-0 py-12">
        <!-- Introduction Section -->
        <section class="mb-16">
            <div class="bg-white rounded-xl p-8 shadow-sm">
                <p class="dropcap text-lg">
                    在Spring框架中，Bean的生命周期是开发者需要深入理解和掌握的重要概念之一。理解Bean的生命周期意味着了解在容器中创建、初始化和销毁Bean实例的过程。这个过程涉及到一系列的步骤和回调方法，开发者可以通过这些方法来在Bean的生命周期不同阶段执行自定义的逻辑。
                </p>
                <p class="mt-4">
                    在整个生命周期中，Spring容器负责管理Bean的创建、初始化和销毁。开发者可以通过配置文件、注解或者编程方式告诉Spring框架如何创建Bean，并通过回调方法在Bean的初始化和销毁时执行特定的操作。这些操作包括资源的初始化、依赖注入、执行自定义初始化逻辑、释放资源等。
                </p>
            </div>
        </section>

        <!-- Lifecycle Stages Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 section-title">生命周期阶段</h2>
            <p class="text-lg mb-8">
                在这些生命周期阶段中，开发人员可以利用Spring框架提供的扩展点来自定义Bean的行为。Spring Bean的生命周期可以分为以下几个阶段：
            </p>
            
            <div class="mermaid-container mb-8">
                <div class="mermaid">
                    graph TD
                        A[实例化 Instantiation] --> B[属性设置 Populate Properties]
                        B --> C[初始化 Initialization]
                        C --> D[使用 In Use]
                        D --> E[销毁 Destruction]
                </div>
            </div>
            
            <div class="grid md:grid-cols-2 lg:grid-cols-5 gap-6">
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-primary-500 mb-4">
                        <i class="fas fa-cube"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">1. 实例化</h3>
                    <p class="text-gray-600">容器实例化Bean对象，这通常是通过构造函数或工厂方法来完成的。</p>
                </div>
                
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-secondary-500 mb-4">
                        <i class="fas fa-pencil-alt"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">2. 属性设置</h3>
                    <p class="text-gray-600">容器将Bean的属性值或依赖注入到Bean中，可以通过构造函数注入、setter方法注入或字段注入来实现。</p>
                </div>
                
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-accent-500 mb-4">
                        <i class="fas fa-play"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">3. 初始化</h3>
                    <p class="text-gray-600">在Bean实例化之后，容器会调用Bean的初始化方法进行一些额外的初始化工作。</p>
                </div>
                
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-purple-500 mb-4">
                        <i class="fas fa-check-circle"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">4. 使用</h3>
                    <p class="text-gray-600">此阶段表示Bean已经被完全初始化，可以被其他Bean或组件使用。</p>
                </div>
                
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-red-500 mb-4">
                        <i class="fas fa-trash-alt"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">5. 销毁</h3>
                    <p class="text-gray-600">当Bean不再被容器使用时，容器会调用Bean的销毁方法进行一些清理工作。</p>
                </div>
            </div>
        </section>

        <!-- Callback Methods Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 section-title">生命周期回调方法</h2>
            <p class="text-lg mb-8">
                Spring Bean的生命周期中涉及到了一些回调方法，这些方法可以在不同的生命周期阶段执行特定的逻辑。主要的生命周期回调方法包括：
            </p>
            
            <div class="mermaid-container mb-8">
                <div class="mermaid">
                    sequenceDiagram
                        participant Container
                        participant Bean
                        Container->>Bean: 实例化 (构造函数)
                        Container->>Bean: 属性注入
                        Container->>Bean: 调用初始化方法 (@PostConstruct)
                        Container->>Bean: Bean准备就绪
                        Container->>Bean: 调用销毁方法 (@PreDestroy)
                </div>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div>
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <span class="w-8 h-8 bg-primary-500 text-white rounded-full flex items-center justify-center mr-3">1</span>
                        构造方法
                    </h3>
                    <p class="text-gray-700">在Bean实例化时调用，用于创建Bean对象。</p>
                </div>
                
                <div>
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <span class="w-8 h-8 bg-secondary-500 text-white rounded-full flex items-center justify-center mr-3">2</span>
                        初始化方法 (@PostConstruct)
                    </h3>
                    <p class="text-gray-700">在Bean实例化完成后，属性注入之后调用，用于执行一些初始化逻辑。</p>
                </div>
                
                <div>
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <span class="w-8 h-8 bg-accent-500 text-white rounded-full flex items-center justify-center mr-3">3</span>
                        销毁方法 (@PreDestroy)
                    </h3>
                    <p class="text-gray-700">在Bean被销毁之前调用，用于执行一些资源释放或清理逻辑。</p>
                </div>
            </div>
            
            <div class="code-block mb-8">
                <pre>import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class MyBean {

    // 初始化方法
    @PostConstruct
    public void init() {
        System.out.println("Bean初始化方法被调用");
        // 执行初始化逻辑
    }

    // 销毁方法
    @PreDestroy
    public void destroy() {
        System.out.println("Bean销毁方法被调用");
        // 执行销毁逻辑
    }
}</pre>
            </div>
            
            <div class="bg-blue-50 p-6 rounded-xl border-l-4 border-blue-500">
                <div class="flex">
                    <div class="flex-shrink-0">
                        <i class="fas fa-info-circle text-blue-500 text-xl mt-1 mr-3"></i>
                    </div>
                    <div>
                        <h4 class="font-semibold text-blue-800 mb-2">专业提示</h4>
                        <p class="text-blue-700">
                            <code>@PostConstruct</code>注解标注的<code>init()</code>方法会在Bean实例化完成后调用，而<code>@PreDestroy</code>注解标注的<code>destroy()</code>方法会在Bean被销毁前调用。开发人员可以在这些初始化方法和销毁方法中编写自己的逻辑代码，用于完成一些特定的初始化或清理操作。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Bean Scopes Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 section-title">Bean的作用域</h2>
            <p class="text-lg mb-8">
                Spring中的Bean作用域定义了Bean对象在容器中的生命周期和可见范围。常见的作用域包括单例（Singleton）、原型（Prototype）、会话（Session）、请求（Request）等。
            </p>
            
            <div class="mermaid-container mb-8">
                <div class="mermaid">
                    pie
                        title Bean作用域分布
                        "Singleton (单例)": 70
                        "Prototype (原型)": 20
                        "Session (会话)": 5
                        "Request (请求)": 5
                </div>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white p-6 rounded-xl shadow-sm">
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-copy text-primary-500 mr-3"></i>
                        单例（Singleton）作用域
                    </h3>
                    <p class="text-gray-700 mb-4">单例作用域是Spring中默认的作用域，它表示在整个Spring容器中只存在一个Bean实例。单例Bean在容器启动时被创建，一直存在于整个应用程序的生命周期中，直到容器关闭。单例Bean被多个对象共享，因此需要注意线程安全问题。</p>
                    
                    <div class="code-block">
                        <pre>import org.springframework.stereotype.Component;

@Component
public class SingletonBean {
    public SingletonBean() {
        System.out.println("SingletonBean被实例化");
    }
}</pre>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-sm">
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-clone text-secondary-500 mr-3"></i>
                        原型（Prototype）作用域
                    </h3>
                    <p class="text-gray-700 mb-4">原型作用域表示每次从容器中获取Bean时都会创建一个新的Bean实例。原型Bean的生命周期由Bean的使用方管理，容器不会对其进行管理和销毁。原型Bean适用于那些不需要容器管理生命周期的情况，例如每次请求都需要创建一个新的对象。</p>
                    
                    <div class="code-block">
                        <pre>import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class PrototypeBean {
    public PrototypeBean() {
        System.out.println("PrototypeBean被实例化");
    }
}</pre>
                    </div>
                </div>
            </div>
            
            <div class="mt-6 bg-yellow-50 p-6 rounded-xl border-l-4 border-yellow-500">
                <div class="flex">
                    <div class="flex-shrink-0">
                        <i class="fas fa-lightbulb text-yellow-500 text-xl mt-1 mr-3"></i>
                    </div>
                    <div>
                        <h4 class="font-semibold text-yellow-800 mb-2">关键区别</h4>
                        <p class="text-yellow-700">
                            <code>SingletonBean</code>被定义为单例作用域，而<code>PrototypeBean</code>被定义为原型作用域。当Spring容器启动时，会创建并初始化<code>SingletonBean</code>实例，并在整个应用程序生命周期中共享该实例；而每次请求<code>PrototypeBean</code>时，都会创建一个新的<code>PrototypeBean</code>实例，不同请求之间的实例是相互独立的。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- BeanPostProcessor Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 section-title">BeanPostProcessor接口</h2>
            <p class="text-lg mb-8">
                <code>BeanPostProcessor</code>接口在Spring容器启动时允许我们在Bean实例化、依赖注入、初始化以及销毁等阶段对Bean进行自定义处理。该接口定义了两个方法：<code>postProcessBeforeInitialization</code>和<code>postProcessAfterInitialization</code>，分别在Bean初始化之前和之后调用。
            </p>
            
            <div class="mermaid-container mb-8">
                <div class="mermaid">
                    flowchart TB
                        subgraph Bean生命周期
                            A[实例化] --> B[属性设置]
                            B --> C[初始化前处理]
                            C --> D[初始化]
                            D --> E[初始化后处理]
                            E --> F[使用]
                            F --> G[销毁]
                        end
                        subgraph BeanPostProcessor
                            H[postProcessBeforeInitialization] --> C
                            I[postProcessAfterInitialization] --> E
                        end
                </div>
            </div>
            
            <div class="grid md:grid-cols-3 gap-6 mb-8">
                <div class="bg-white p-6 rounded-xl shadow-sm">
                    <h3 class="text-lg font-semibold mb-3 flex items-center">
                        <i class="fas fa-angle-double-right text-primary-500 mr-2"></i>
                        Bean实例化阶段
                    </h3>
                    <p class="text-gray-700 text-sm">在Bean实例化之前，Spring会先检测容器中是否存在实现了<code>BeanPostProcessor</code>接口的Bean。如果有，容器会将这些<code>BeanPostProcessor</code>实例化并放入一个专门的列表中。</p>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-sm">
                    <h3 class="text-lg font-semibold mb-3 flex items-center">
                        <i class="fas fa-angle-double-right text-secondary-500 mr-2"></i>
                        Bean初始化阶段
                    </h3>
                    <p class="text-gray-700 text-sm">
                        1. <code>postProcessBeforeInitialization</code>方法被调用<br>
                        2. Bean的初始化方法被调用<br>
                        3. <code>postProcessAfterInitialization</code>方法被调用
                    </p>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-sm">
                    <h3 class="text-lg font-semibold mb-3 flex items-center">
                        <i class="fas fa-angle-double-right text-accent-500 mr-2"></i>
                        Bean销毁阶段
                    </h3>
                    <p class="text-gray-700 text-sm">如果Bean实现了<code>DisposableBean</code>接口或者定义了<code>destroy-method</code>，当容器关闭时，Spring将调用Bean的销毁方法。</p>
                </div>
            </div>
            
            <div class="code-block mb-8">
                <pre>import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeforeInitialization : " + beanName);
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("AfterInitialization : " + beanName);
        return bean;
    }
}</pre>
            </div>
            
            <div class="bg-purple-50 p-6 rounded-xl border-l-4 border-purple-500">
                <div class="flex">
                    <div class="flex-shrink-0">
                        <i class="fas fa-code text-purple-500 text-xl mt-1 mr-3"></i>
                    </div>
                    <div>
                        <h4 class="font-semibold text-purple-800 mb-2">代码解析</h4>
                        <p class="text-purple-700">
                            <code>CustomBeanPostProcessor</code>实现了<code>BeanPostProcessor</code>接口，覆盖了<code>postProcessBeforeInitialization</code>和<code>postProcessAfterInitialization</code>方法，在Bean初始化前后分别打印了日志。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Lazy Initialization Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 section-title">Bean的延迟初始化</h2>
            <p class="text-lg mb-8">
                Spring允许我们通过配置来控制Bean的延迟初始化，即在容器启动时是否立即创建Bean实例。延迟初始化可以提高应用程序的性能，特别是当应用程序包含大量的Bean或者某些Bean只在特定条件下被使用时。在Spring中，有几种方式可以实现Bean的延迟初始化：
            </p>
            
            <div class="mermaid-container mb-8">
                <div class="mermaid">
                    gantt
                        title Bean初始化时间线
                        dateFormat  HH:mm:ss
                        section 立即初始化
                        容器启动 :a1, 00:00:00, 5s
                        Bean初始化 :a2, after a1, 3s
                        section 延迟初始化
                        容器启动 :b1, 00:00:00, 5s
                        首次请求 :b2, after b1, 10s
                        Bean初始化 :b3, after b2, 3s
                </div>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-tag text-primary-500 mr-3"></i>
                        使用 lazy-init 属性
                    </h3>
                    <p class="text-gray-700 mb-4">在XML配置文件中，可以使用<code>lazy-init</code>属性将Bean的延迟初始化设置为<code>true</code>，这样在容器启动时不会立即创建Bean实例，而是在首次被请求时才会创建。</p>
                    
                    <div class="code-block">
                        <pre>&lt;bean id="exampleBean" class="com.example.ExampleBean" lazy-init="true"/&gt;</pre>
                    </div>
                </div>
                
                <div>
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-at text-secondary-500 mr-3"></i>
                        使用 @Lazy 注解
                    </h3>
                    <p class="text-gray-700 mb-4">在使用Java配置或者注解配置时，可以使用<code>@Lazy</code>注解将Bean的延迟初始化设置为<code>true</code>。</p>
                    
                    <div class="code-block">
                        <pre>@Component
@Lazy
public class ExampleBean {
    // Bean定义
}</pre>
                    </div>
                </div>
            </div>
            
            <div class="mt-8">
                <h3 class="text-xl font-semibold mb-4 flex items-center">
                    <i class="fas fa-cog text-accent-500 mr-3"></i>
                    高级延迟初始化配置
                </h3>
                
                <div class="grid md:grid-cols-3 gap-6">
                    <div class="bg-white p-6 rounded-xl shadow-sm">
                        <h4 class="font-semibold mb-2 flex items-center">
                            <i class="fas fa-question-circle text-blue-500 mr-2"></i>
                            条件延迟初始化
                        </h4>
                        <p class="text-gray-700 text-sm">使用条件判断来动态决定是否延迟初始化Bean。可以在<code>@Configuration</code>类中使用<code>@Conditional</code>注解，根据特定条件来决定是否初始化Bean。</p>
                    </div>
                    
                    <div class="bg-white p-6 rounded-xl shadow-sm">
                        <h4 class="font-semibold mb-2 flex items-center">
                            <i class="fas fa-object-group text-green-500 mr-2"></i>
                            @Lazy 配置类
                        </h4>
                        <p class="text-gray-700 text-sm">如果<code>@Configuration</code>类被标记为<code>@Lazy</code>，则其中定义的所有Bean都将被延迟初始化。</p>
                    </div>
                    
                    <div class="bg-white p-6 rounded-xl shadow-sm">
                        <h4 class="font-semibold mb-2 flex items-center">
                            <i class="fas fa-filter text-purple-500 mr-2"></i>
                            条件装配
                        </h4>
                        <p class="text-gray-700 text-sm">可以使用<code>@Conditional</code>注解，根据条件决定是否加载特定的配置类或者Bean。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Application Scenarios Section -->
        <section>
            <h2 class="text-3xl font-bold mb-8 section-title">Bean生命周期的应用场景</h2>
            <p class="text-lg mb-8">
                一些常见的应用场景，例如在初始化阶段执行一些特定的逻辑，如加载资源、建立数据库连接等，或者在销毁阶段执行一些清理工作，如释放资源、关闭连接等。
            </p>
            
            <div class="grid md:grid-cols-2 lg:grid-cols-3 gap-6">
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-blue-500 mb-4">
                        <i class="fas fa-database"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">初始化资源</h3>
                    <p class="text-gray-600">在Bean的生命周期中，可以通过实现<code>InitializingBean</code>接口或者在配置文件中指定<code>init-method</code>来执行一些初始化操作，例如数据库连接、资源加载、初始化配置等。</p>
                </div>
                
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-red-500 mb-4">
                        <i class="fas fa-trash-restore"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">销毁资源</h3>
                    <p class="text-gray-600">当Bean不再需要时，可以通过实现<code>DisposableBean</code>接口或者在配置文件中指定<code>destroy-method</code>来执行一些资源的清理操作。</p>
                </div>
                
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-green-500 mb-4">
                        <i class="fas fa-project-diagram"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">AOP（面向切面编程）</h3>
                    <p class="text-gray-600">Spring框架通过代理机制实现了AOP功能，可以在Bean的生命周期中动态地添加、修改、删除Advice以及Pointcut。</p>
                </div>
                
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-purple-500 mb-4">
                        <i class="fas fa-bell"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">事件驱动编程</h3>
                    <p class="text-gray-600">Spring框架提供了事件驱动编程的支持，可以在Bean的生命周期中发布和监听事件，实现模块之间的解耦和通信。</p>
                </div>
                
                <div class="card bg-white p-6 rounded-xl">
                    <div class="text-4xl text-yellow-500 mb-4">
                        <i class="fas fa-clock"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-2">定时任务</h3>
                    <p class="text-gray-600">Spring框架提供了定时任务的支持，可以通过配置定时任务Bean来在指定的时间间隔或时间点执行特定的任务。</p>
                </div>
            </div>
        </section>
    </div>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            },
            pie: {
                useMaxWidth: true
            },
            gantt: {
                useMaxWidth: true
            }
        });
    </script>
</body>
</html>
```